home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / berzerk.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  5KB  |  190 lines
  1. /***************************************************************************
  2.  
  3.   vidhrdw.c
  4.  
  5.   Functions to emulate the video hardware of the machine.
  6.  
  7. ***************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "vidhrdw/generic.h"
  11.  
  12. unsigned char *berzerk_magicram;
  13. extern int berzerk_irq_end_of_screen;
  14.  
  15. static int magicram_control = 0xff;
  16. static int magicram_latch = 0xff;
  17. static int collision = 0;
  18.  
  19.  
  20. INLINE void copy_byte(int x, int y, int data, int col)
  21. {
  22.     UINT16 fore, back;
  23.  
  24.  
  25.     if (y < 32)  return;
  26.  
  27.     fore  = Machine->pens[(col >> 4) & 0x0f];
  28.     back  = Machine->pens[0];
  29.  
  30.     plot_pixel(Machine->scrbitmap, x  , y, (data & 0x80) ? fore : back);
  31.     plot_pixel(Machine->scrbitmap, x+1, y, (data & 0x40) ? fore : back);
  32.     plot_pixel(Machine->scrbitmap, x+2, y, (data & 0x20) ? fore : back);
  33.     plot_pixel(Machine->scrbitmap, x+3, y, (data & 0x10) ? fore : back);
  34.  
  35.     fore  = Machine->pens[col & 0x0f];
  36.  
  37.     plot_pixel(Machine->scrbitmap, x+4, y, (data & 0x08) ? fore : back);
  38.     plot_pixel(Machine->scrbitmap, x+5, y, (data & 0x04) ? fore : back);
  39.     plot_pixel(Machine->scrbitmap, x+6, y, (data & 0x02) ? fore : back);
  40.     plot_pixel(Machine->scrbitmap, x+7, y, (data & 0x01) ? fore : back);
  41. }
  42.  
  43.  
  44. WRITE_HANDLER( berzerk_videoram_w )
  45. {
  46.     int coloroffset, x, y;
  47.  
  48.     videoram[offset] = data;
  49.  
  50.     /* Get location of color RAM for this offset */
  51.     coloroffset = ((offset & 0xff80) >> 2) | (offset & 0x1f);
  52.  
  53.     y = (offset >> 5);
  54.     x = (offset & 0x1f) << 3;
  55.  
  56.     copy_byte(x, y, data, colorram[coloroffset]);
  57. }
  58.  
  59.  
  60. WRITE_HANDLER( berzerk_colorram_w )
  61. {
  62.     int x, y, i;
  63.  
  64.     colorram[offset] = data;
  65.  
  66.     /* Need to change the affected pixels' colors */
  67.  
  68.     y = ((offset >> 3) & 0xfc);
  69.     x = (offset & 0x1f) << 3;
  70.  
  71.     for (i = 0; i < 4; i++, y++)
  72.     {
  73.         int byte = videoram[(y << 5) | (x >> 3)];
  74.  
  75.         if (byte)
  76.         {
  77.             copy_byte(x, y, byte, data);
  78.         }
  79.     }
  80. }
  81.  
  82. INLINE unsigned char reverse_byte(unsigned char data)
  83. {
  84.     return ((data & 0x01) << 7) |
  85.            ((data & 0x02) << 5) |
  86.            ((data & 0x04) << 3) |
  87.            ((data & 0x08) << 1) |
  88.            ((data & 0x10) >> 1) |
  89.            ((data & 0x20) >> 3) |
  90.            ((data & 0x40) >> 5) |
  91.            ((data & 0x80) >> 7);
  92. }
  93.  
  94. INLINE int shifter_flopper(unsigned char data)
  95. {
  96.     int shift_amount, outval;
  97.  
  98.     /* Bits 0-2 are the shift amount */
  99.  
  100.     shift_amount = magicram_control & 0x06;
  101.  
  102.     outval = ((data >> shift_amount) | (magicram_latch << (8 - shift_amount))) & 0x1ff;
  103.     outval >>= (magicram_control & 0x01);
  104.  
  105.  
  106.     /* Bit 3 is the flip bit */
  107.     if (magicram_control & 0x08)
  108.     {
  109.         outval = reverse_byte(outval);
  110.     }
  111.  
  112.     return outval;
  113. }
  114.  
  115.  
  116. WRITE_HANDLER( berzerk_magicram_w )
  117. {
  118.     int data2;
  119.  
  120.     data2 = shifter_flopper(data);
  121.  
  122.     magicram_latch = data;
  123.  
  124.     /* Check for collision */
  125.     if (!collision)
  126.     {
  127.         collision = (data2 & videoram[offset]);
  128.     }
  129.  
  130.     switch (magicram_control & 0xf0)
  131.     {
  132.     case 0x00: berzerk_magicram[offset] = data2;                         break;
  133.     case 0x10: berzerk_magicram[offset] = data2 |  videoram[offset];     break;
  134.     case 0x20: berzerk_magicram[offset] = data2 | ~videoram[offset];     break;
  135.     case 0x30: berzerk_magicram[offset] = 0xff;                          break;
  136.     case 0x40: berzerk_magicram[offset] = data2 & videoram[offset];     break;
  137.     case 0x50: berzerk_magicram[offset] = videoram[offset];             break;
  138.     case 0x60: berzerk_magicram[offset] = ~(data2 ^ videoram[offset]);     break;
  139.     case 0x70: berzerk_magicram[offset] = ~data2 | videoram[offset];     break;
  140.     case 0x80: berzerk_magicram[offset] = data2 & ~videoram[offset];    break;
  141.     case 0x90: berzerk_magicram[offset] = data2 ^ videoram[offset];        break;
  142.     case 0xa0: berzerk_magicram[offset] = ~videoram[offset];            break;
  143.     case 0xb0: berzerk_magicram[offset] = ~(data2 & videoram[offset]);     break;
  144.     case 0xc0: berzerk_magicram[offset] = 0x00;                         break;
  145.     case 0xd0: berzerk_magicram[offset] = ~data2 & videoram[offset];     break;
  146.     case 0xe0: berzerk_magicram[offset] = ~(data2 | videoram[offset]);     break;
  147.     case 0xf0: berzerk_magicram[offset] = ~data2;                         break;
  148.     }
  149.  
  150.     berzerk_videoram_w(offset, berzerk_magicram[offset]);
  151. }
  152.  
  153.  
  154. WRITE_HANDLER( berzerk_magicram_control_w )
  155. {
  156.     magicram_control = data;
  157.     magicram_latch = 0;
  158.     collision = 0;
  159. }
  160.  
  161.  
  162. READ_HANDLER( berzerk_collision_r )
  163. {
  164.     int ret = (collision ? 0x80 : 0x00);
  165.  
  166.     return ret | berzerk_irq_end_of_screen;
  167. }
  168.  
  169.  
  170. /***************************************************************************
  171.  
  172.   Draw the game screen in the given osd_bitmap.
  173.   To be used by bitmapped games not using sprites.
  174.  
  175. ***************************************************************************/
  176. void berzerk_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  177. {
  178.     if (full_refresh)
  179.     {
  180.         /* redraw bitmap */
  181.  
  182.         int offs;
  183.  
  184.         for (offs = 0; offs < videoram_size; offs++)
  185.         {
  186.             berzerk_videoram_w(offs, videoram[offs]);
  187.         }
  188.     }
  189. }
  190.